home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / WeakHashMap.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  6.5 KB  |  401 lines
  1. package java.util;
  2.  
  3. import java.lang.ref.ReferenceQueue;
  4.  
  5. public class WeakHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V> {
  6.    private static final int DEFAULT_INITIAL_CAPACITY = 16;
  7.    private static final int MAXIMUM_CAPACITY = 1073741824;
  8.    private static final float DEFAULT_LOAD_FACTOR = 0.75F;
  9.    private Entry[] table;
  10.    private int size;
  11.    private int threshold;
  12.    private final float loadFactor;
  13.    private final ReferenceQueue<K> queue;
  14.    private volatile int modCount;
  15.    private static final Object NULL_KEY = new Object();
  16.    private transient Set<Map.Entry<K, V>> entrySet;
  17.  
  18.    public WeakHashMap(int var1, float var2) {
  19.       this.queue = new ReferenceQueue();
  20.       this.entrySet = null;
  21.       if (var1 < 0) {
  22.          throw new IllegalArgumentException("Illegal Initial Capacity: " + var1);
  23.       } else {
  24.          if (var1 > 1073741824) {
  25.             var1 = 1073741824;
  26.          }
  27.  
  28.          if (!(var2 <= 0.0F) && !Float.isNaN(var2)) {
  29.             int var3;
  30.             for(var3 = 1; var3 < var1; var3 <<= 1) {
  31.             }
  32.  
  33.             this.table = new Entry[var3];
  34.             this.loadFactor = var2;
  35.             this.threshold = (int)((float)var3 * var2);
  36.          } else {
  37.             throw new IllegalArgumentException("Illegal Load factor: " + var2);
  38.          }
  39.       }
  40.    }
  41.  
  42.    public WeakHashMap(int var1) {
  43.       this(var1, 0.75F);
  44.    }
  45.  
  46.    public WeakHashMap() {
  47.       this.queue = new ReferenceQueue();
  48.       this.entrySet = null;
  49.       this.loadFactor = 0.75F;
  50.       this.threshold = 16;
  51.       this.table = new Entry[16];
  52.    }
  53.  
  54.    public WeakHashMap(Map<? extends K, ? extends V> var1) {
  55.       this(Math.max((int)((float)var1.size() / 0.75F) + 1, 16), 0.75F);
  56.       this.putAll(var1);
  57.    }
  58.  
  59.    private static Object maskNull(Object var0) {
  60.       return var0 == null ? NULL_KEY : var0;
  61.    }
  62.  
  63.    private static <K> K unmaskNull(Object var0) {
  64.       return (K)(var0 == NULL_KEY ? null : var0);
  65.    }
  66.  
  67.    // $FF: renamed from: eq (java.lang.Object, java.lang.Object) boolean
  68.    static boolean method_0(Object var0, Object var1) {
  69.       return var0 == var1 || var0.equals(var1);
  70.    }
  71.  
  72.    static int indexFor(int var0, int var1) {
  73.       return var0 & var1 - 1;
  74.    }
  75.  
  76.    private void expungeStaleEntries() {
  77.       label25:
  78.       while(true) {
  79.          Entry var1;
  80.          if ((var1 = (Entry)this.queue.poll()) != null) {
  81.             int var2 = java.util.WeakHashMap.Entry.access$000(var1);
  82.             int var3 = indexFor(var2, this.table.length);
  83.             Entry var4 = this.table[var3];
  84.             Entry var5 = var4;
  85.  
  86.             while(true) {
  87.                if (var5 == null) {
  88.                   continue label25;
  89.                }
  90.  
  91.                Entry var6 = java.util.WeakHashMap.Entry.access$100(var5);
  92.                if (var5 == var1) {
  93.                   if (var4 == var1) {
  94.                      this.table[var3] = var6;
  95.                   } else {
  96.                      java.util.WeakHashMap.Entry.access$102(var4, var6);
  97.                   }
  98.  
  99.                   java.util.WeakHashMap.Entry.access$102(var1, (Entry)null);
  100.                   java.util.WeakHashMap.Entry.access$202(var1, (Object)null);
  101.                   --this.size;
  102.                   continue label25;
  103.                }
  104.  
  105.                var4 = var5;
  106.                var5 = var6;
  107.             }
  108.          }
  109.  
  110.          return;
  111.       }
  112.    }
  113.  
  114.    private Entry[] getTable() {
  115.       this.expungeStaleEntries();
  116.       return this.table;
  117.    }
  118.  
  119.    public int size() {
  120.       if (this.size == 0) {
  121.          return 0;
  122.       } else {
  123.          this.expungeStaleEntries();
  124.          return this.size;
  125.       }
  126.    }
  127.  
  128.    public boolean isEmpty() {
  129.       return this.size() == 0;
  130.    }
  131.  
  132.    public V get(Object var1) {
  133.       Object var2 = maskNull(var1);
  134.       int var3 = HashMap.hash(var2.hashCode());
  135.       Entry[] var4 = this.getTable();
  136.       int var5 = indexFor(var3, var4.length);
  137.  
  138.       for(Entry var6 = var4[var5]; var6 != null; var6 = java.util.WeakHashMap.Entry.access$100(var6)) {
  139.          if (java.util.WeakHashMap.Entry.access$000(var6) == var3 && method_0(var2, var6.get())) {
  140.             return (V)java.util.WeakHashMap.Entry.access$200(var6);
  141.          }
  142.       }
  143.  
  144.       return null;
  145.    }
  146.  
  147.    public boolean containsKey(Object var1) {
  148.       return this.getEntry(var1) != null;
  149.    }
  150.  
  151.    Entry<K, V> getEntry(Object var1) {
  152.       Object var2 = maskNull(var1);
  153.       int var3 = HashMap.hash(var2.hashCode());
  154.       Entry[] var4 = this.getTable();
  155.       int var5 = indexFor(var3, var4.length);
  156.  
  157.       Entry var6;
  158.       for(var6 = var4[var5]; var6 != null && (java.util.WeakHashMap.Entry.access$000(var6) != var3 || !method_0(var2, var6.get())); var6 = java.util.WeakHashMap.Entry.access$100(var6)) {
  159.       }
  160.  
  161.       return var6;
  162.    }
  163.  
  164.    public V put(K var1, V var2) {
  165.       Object var3 = maskNull(var1);
  166.       int var4 = HashMap.hash(var3.hashCode());
  167.       Entry[] var5 = this.getTable();
  168.       int var6 = indexFor(var4, var5.length);
  169.  
  170.       for(Entry var7 = var5[var6]; var7 != null; var7 = java.util.WeakHashMap.Entry.access$100(var7)) {
  171.          if (var4 == java.util.WeakHashMap.Entry.access$000(var7) && method_0(var3, var7.get())) {
  172.             Object var8 = java.util.WeakHashMap.Entry.access$200(var7);
  173.             if (var2 != var8) {
  174.                java.util.WeakHashMap.Entry.access$202(var7, var2);
  175.             }
  176.  
  177.             return (V)var8;
  178.          }
  179.       }
  180.  
  181.       ++this.modCount;
  182.       Entry var9 = var5[var6];
  183.       var5[var6] = new Entry(var3, var2, this.queue, var4, var9);
  184.       if (++this.size >= this.threshold) {
  185.          this.resize(var5.length * 2);
  186.       }
  187.  
  188.       return null;
  189.    }
  190.  
  191.    void resize(int var1) {
  192.       Entry[] var2 = this.getTable();
  193.       int var3 = var2.length;
  194.       if (var3 == 1073741824) {
  195.          this.threshold = Integer.MAX_VALUE;
  196.       } else {
  197.          Entry[] var4 = new Entry[var1];
  198.          this.transfer(var2, var4);
  199.          this.table = var4;
  200.          if (this.size >= this.threshold / 2) {
  201.             this.threshold = (int)((float)var1 * this.loadFactor);
  202.          } else {
  203.             this.expungeStaleEntries();
  204.             this.transfer(var4, var2);
  205.             this.table = var2;
  206.          }
  207.  
  208.       }
  209.    }
  210.  
  211.    private void transfer(Entry[] var1, Entry[] var2) {
  212.       for(int var3 = 0; var3 < var1.length; ++var3) {
  213.          Entry var4 = var1[var3];
  214.  
  215.          Entry var5;
  216.          for(var1[var3] = null; var4 != null; var4 = var5) {
  217.             var5 = java.util.WeakHashMap.Entry.access$100(var4);
  218.             Object var6 = var4.get();
  219.             if (var6 == null) {
  220.                java.util.WeakHashMap.Entry.access$102(var4, (Entry)null);
  221.                java.util.WeakHashMap.Entry.access$202(var4, (Object)null);
  222.                --this.size;
  223.             } else {
  224.                int var7 = indexFor(java.util.WeakHashMap.Entry.access$000(var4), var2.length);
  225.                java.util.WeakHashMap.Entry.access$102(var4, var2[var7]);
  226.                var2[var7] = var4;
  227.             }
  228.          }
  229.       }
  230.  
  231.    }
  232.  
  233.    public void putAll(Map<? extends K, ? extends V> var1) {
  234.       int var2 = var1.size();
  235.       if (var2 != 0) {
  236.          if (var2 > this.threshold) {
  237.             int var3 = (int)((float)var2 / this.loadFactor + 1.0F);
  238.             if (var3 > 1073741824) {
  239.                var3 = 1073741824;
  240.             }
  241.  
  242.             int var4;
  243.             for(var4 = this.table.length; var4 < var3; var4 <<= 1) {
  244.             }
  245.  
  246.             if (var4 > this.table.length) {
  247.                this.resize(var4);
  248.             }
  249.          }
  250.  
  251.          for(Map.Entry var6 : var1.entrySet()) {
  252.             this.put(var6.getKey(), var6.getValue());
  253.          }
  254.  
  255.       }
  256.    }
  257.  
  258.    public V remove(Object var1) {
  259.       Object var2 = maskNull(var1);
  260.       int var3 = HashMap.hash(var2.hashCode());
  261.       Entry[] var4 = this.getTable();
  262.       int var5 = indexFor(var3, var4.length);
  263.       Entry var6 = var4[var5];
  264.  
  265.       Entry var8;
  266.       for(Entry var7 = var6; var7 != null; var7 = var8) {
  267.          var8 = java.util.WeakHashMap.Entry.access$100(var7);
  268.          if (var3 == java.util.WeakHashMap.Entry.access$000(var7) && method_0(var2, var7.get())) {
  269.             ++this.modCount;
  270.             --this.size;
  271.             if (var6 == var7) {
  272.                var4[var5] = var8;
  273.             } else {
  274.                java.util.WeakHashMap.Entry.access$102(var6, var8);
  275.             }
  276.  
  277.             return (V)java.util.WeakHashMap.Entry.access$200(var7);
  278.          }
  279.  
  280.          var6 = var7;
  281.       }
  282.  
  283.       return null;
  284.    }
  285.  
  286.    Entry<K, V> removeMapping(Object var1) {
  287.       if (!(var1 instanceof Map.Entry)) {
  288.          return null;
  289.       } else {
  290.          Entry[] var2 = this.getTable();
  291.          Map.Entry var3 = (Map.Entry)var1;
  292.          Object var4 = maskNull(var3.getKey());
  293.          int var5 = HashMap.hash(var4.hashCode());
  294.          int var6 = indexFor(var5, var2.length);
  295.          Entry var7 = var2[var6];
  296.  
  297.          Entry var9;
  298.          for(Entry var8 = var7; var8 != null; var8 = var9) {
  299.             var9 = java.util.WeakHashMap.Entry.access$100(var8);
  300.             if (var5 == java.util.WeakHashMap.Entry.access$000(var8) && var8.equals(var3)) {
  301.                ++this.modCount;
  302.                --this.size;
  303.                if (var7 == var8) {
  304.                   var2[var6] = var9;
  305.                } else {
  306.                   java.util.WeakHashMap.Entry.access$102(var7, var9);
  307.                }
  308.  
  309.                return var8;
  310.             }
  311.  
  312.             var7 = var8;
  313.          }
  314.  
  315.          return null;
  316.       }
  317.    }
  318.  
  319.    public void clear() {
  320.       while(this.queue.poll() != null) {
  321.       }
  322.  
  323.       ++this.modCount;
  324.       Entry[] var1 = this.table;
  325.  
  326.       for(int var2 = 0; var2 < var1.length; ++var2) {
  327.          var1[var2] = null;
  328.       }
  329.  
  330.       this.size = 0;
  331.  
  332.       while(this.queue.poll() != null) {
  333.       }
  334.  
  335.    }
  336.  
  337.    public boolean containsValue(Object var1) {
  338.       if (var1 == null) {
  339.          return this.containsNullValue();
  340.       } else {
  341.          Entry[] var2 = this.getTable();
  342.          int var3 = var2.length;
  343.  
  344.          while(var3-- > 0) {
  345.             for(Entry var4 = var2[var3]; var4 != null; var4 = java.util.WeakHashMap.Entry.access$100(var4)) {
  346.                if (var1.equals(java.util.WeakHashMap.Entry.access$200(var4))) {
  347.                   return true;
  348.                }
  349.             }
  350.          }
  351.  
  352.          return false;
  353.       }
  354.    }
  355.  
  356.    private boolean containsNullValue() {
  357.       Entry[] var1 = this.getTable();
  358.       int var2 = var1.length;
  359.  
  360.       while(var2-- > 0) {
  361.          for(Entry var3 = var1[var2]; var3 != null; var3 = java.util.WeakHashMap.Entry.access$100(var3)) {
  362.             if (java.util.WeakHashMap.Entry.access$200(var3) == null) {
  363.                return true;
  364.             }
  365.          }
  366.       }
  367.  
  368.       return false;
  369.    }
  370.  
  371.    public Set<K> keySet() {
  372.       Set var1 = this.keySet;
  373.       return var1 != null ? var1 : (this.keySet = new KeySet(this, (1)null));
  374.    }
  375.  
  376.    public Collection<V> values() {
  377.       Collection var1 = this.values;
  378.       return var1 != null ? var1 : (this.values = new Values(this, (1)null));
  379.    }
  380.  
  381.    public Set<Map.Entry<K, V>> entrySet() {
  382.       Set var1 = this.entrySet;
  383.       return var1 != null ? var1 : (this.entrySet = new EntrySet(this, (1)null));
  384.    }
  385.  
  386.    // $FF: synthetic method
  387.    static Object access$300(Object var0) {
  388.       return unmaskNull(var0);
  389.    }
  390.  
  391.    // $FF: synthetic method
  392.    static int access$400(WeakHashMap var0) {
  393.       return var0.modCount;
  394.    }
  395.  
  396.    // $FF: synthetic method
  397.    static Entry[] access$500(WeakHashMap var0) {
  398.       return var0.table;
  399.    }
  400. }
  401.